#ifndef COMMAND_ROOM_COMMAND_H_
#define COMMAND_ROOM_COMMAND_H_
#include "command.h"

#ifdef _WIN32
#pragma warning( push )
#pragma warning( disable : 4200 )
#endif

#pragma pack(1)
namespace Cmd
{
        //所有与特定房间相关的指令继承自stRoomCmd
        struct stRoomCmd:
                t_NullCmd
        {
                stRoomCmd(const WORD &scmd):
                        t_NullCmd(CMD_ROOM, scmd)
                {
                        room_id_ = 0;
                }
                stRoomCmd(const WORD cmd, const WORD scmd):
                        t_NullCmd(cmd, scmd)
                {
                        room_id_ = 0;
                }
                void setRoomID(const uint32_t &roomid)
                {
                        room_id_ = roomid;
                }
                DWORD room_id_;                                 // 房间ID 
        };

        enum //CMD_ROOM
        {
                SCMD_ROOM_NULL                          = 0x0000,
                SCMD_ROOM_JOIN_old                      = 0x0001,	// 进入房间
                SCMD_ROOM_JOIN_RES                      = 0x0002,	// 进入房间结果
                SCMD_ROOM_NOTIFY_JOIN_old               = 0x0003,	// 进入房间 通知房间内用户
                SCMD_ROOM_LEAVE                         = 0x0004,	// 退出房间
                SCMD_ROOM_NOTIFY_LEAVE                  = 0x0005,	// 退出房间 通知房间内用户
                SCMD_ROOM_REQ_BASE_INFO_old             = 0x0006,	// 请求房间基本信息
                SCMD_ROOM_RES_BASE_INFO_old             = 0x0007,	// 返回房间基本信息
                SCMD_ROOM_RES_ADDR_INFO                 = 0x0008,	// 放回房间地址信息
                SCMD_ROOM_REQ_MANAGER_LIST              = 0x0009,	// 请求管理员列表
                SCMD_ROOM_RES_MANAGER_LIST              = 0x000A,	// 返回管理员列表
                SCMD_ROOM_REQ_USER_LIST_old             = 0x000B,	// 请求方将用户列表
                SCMD_ROOM_RES_USER_LIST_old             = 0x000C,	// 返回房间用户列表
                SCMD_ROOM_REQ_MIC_QUEUE                 = 0x000D,	// 请求房间的麦序列表
                SCMD_ROOM_RES_MIC_QUEUE                 = 0x000E,	// 返回房间的麦序列表
                SCMD_ROOM_JOIN_INFO_END                 = 0x000F,	// 进入房间流程结束
                SCMD_ROOM_CHAT_SEND                     = 0x0010,	// 发送聊天消息
                SCMD_ROOM_CHAT_RECV                     = 0x0011,	// 接收聊天消息
                SCMD_ROOM_REQ_CHANGE_MODE               = 0x0012,	// 管理员请求变更房间模式
                SCMD_ROOM_RES_CHANGE_MODE               = 0x0013,	// 管理员变换房间模式结果
                SCMD_ROOM_NOTIFY_CHANGE_MODE            = 0x0014,	// 通知房间用户:变更房间模式
                SCMD_ROOM_JOIN_MIC_QUEUE                = 0x0015,	// 用户抢麦
                SCMD_ROOM_JOIN_MIC_QUEUE_RES            = 0x0016,	// 用户抢麦结果
                SCMD_ROOM_NOTIFY_JOIN_MIC_QUEUE         = 0x0017,       // 用户抢麦成功通知房间用户
                SCMD_ROOM_LEAVE_MIC_QUEUE               = 0x0018,	// 用户下麦
                SCMD_ROOM_LEAVE_MIC_QUEUE_RES           = 0x0019,	// 用户下麦结果
                SCMD_ROOM_NOTIFY_LEAVE_MIC_QUEUE        = 0x001A,       // 用户下麦后通知房间用户
                SCMD_ROOM_HAND_UP                       = 0x001B,	// 用户举手
                SCMD_ROOM_HAND_UP_RES                   = 0x001C,	// 用户举手结果
                SCMD_ROOM_NOTIFY_HAND_UP                = 0x001D,	// 用户举手成功通知房间用户
                SCMD_ROOM_HAND_OFF                      = 0x001E,	// 用户放手
                SCMD_ROOM_HAND_OFF_RES                  = 0x001F,	// 用户放手结果
                SCMD_ROOM_NOTIFY_HAND_OFF               = 0x0020,	// 用户放手通知房间用户
                SCMD_ROOM_REQ_HANDUP_LIST               = 0x0021,	// 请求房间内举手列表
                SCMD_ROOM_RES_HANDUP_LIST               = 0x0022,	// 返回房间内的举手列表
                SCMD_ROOM_ADD_USER_TO_MIC               = 0x0023,	// 管理员将用户加入麦序
                SCMD_ROOM_ADD_USER_TO_MIC_RES           = 0x0024,	// 管理员将用户加入麦序 返回结果
                SCMD_ROOM_NOTIFY_ADD_USER_TO_MIC        = 0x0025,       // 管理员将用户加入麦序 通知房间用户
                SCMD_ROOM_REMOVE_USER_FROM_MIC          = 0x0026,       // 管理员将用户从麦序队列中移掉
                SCMD_ROOM_REMOVE_USER_FROM_MIC_RES      = 0x0027,       // 管理员将用户从麦序队列中移掉 返回结果
                SCMD_ROOM_REMOVE_USER_FROM_MIC_NOTIFY   = 0x0028,       // 管理员将用户从麦序队列中移掉 通知房间用户
                SCMD_ROOM_REQ_APP_BIT_MASK              = 0x0029,       // 请求房间应用标志
                SCMD_ROOM_RES_APP_BIT_MASK              = 0x002A,       // 返回房间应用标志
                SCMD_ROOM_WHITE_BOARD_ADD_DOC_LINK_REQ  = 0x002C,       // 房间新增文档地址
                SCMD_ROOM_WHITE_BOARD_REQ_DOC_LINK_old  = 0x002D,       // 房间用户请求文档下载地址
                SCMD_ROOM_WHITE_BOARD_RES_DOC_LINK_old  = 0x002E,       // 通知房间用户文档下载地址
                SCMD_ROOM_WHITE_BOARD_DEL_DOC_LINK      = 0x002F,       // 通知删除文档下载地址(结束本文档)
                SCMD_ROOM_WHITE_BOARD_REQ_INFO          = 0x0030,       // 请求房间白板信息
                SCMD_ROOM_WHITE_BOARD_RES_SHAPE         = 0x0031,       // 返回房间白板信息-图形
                SCMD_ROOM_WHITE_BOARD_RES_TEXT          = 0x0032,       // 返回房间白板信息-文本
                SCMD_ROOM_WHITE_BOARD_ADD_SHAPE         = 0x0033,       // 房间白板 增加形状笔记
                SCMD_ROOM_WHITE_BOARD_ADD_TEXT          = 0x0034,       // 房间白板 增加文本笔记
                SCMD_ROOM_WHITE_BOARD_ERASE_ELEMENT     = 0x0035,       // 擦除白板的某条笔记
                SCMD_ROOM_WHITE_BOARD_CLEAR             = 0x0036,       // 清除白板
                SCMD_ROOM_WHITE_BOARD_PAGE              = 0x0037,       // 讲义/白板翻页
                SCMD_ROOM_WHITE_BOARD_CURSOR            = 0x0038,       // 光标位置
                SCMD_ROOM_REQ_SHOW_INFO                 = 0x0039,       // 请求房间的显示信息
                SCMD_ROOM_RES_SHOW_INFO                 = 0x003A,       // 返回房间的显示信息
                SCMD_ROOM_SET_USER_SHOW_IDENTITY        = 0x003B,       // 设置用户的伪装身份
                SCMD_ROOM_CONTROL_STATUS_SET_old        = 0x003C,       // 用户请求设置某些房间的控制状态
                SCMD_ROOM_CONTROL_STATUS_SET_RES        = 0x003D,       // 返回房间控制状态的设置结果
                SCMD_ROOM_CONTROL_STATUS_NOTIFY         = 0x003E,       // 通知用户房间当前的控制状态
                SCMD_ROOM_UPDATE_MIC_TIME               = 0x003F,       // 设置房间的麦序时间
                SCMD_ROOM_NOTIFY_SPEAK_USERS            = 0x0040,       // 通知房间用户当前可以说话的用户
                SCMD_ROOM_BLACK_LIST_REQ                = 0x0041,       // 用户请求房间的黑名单列表
                SCMD_ROOM_BLACK_LIST_RES                = 0x0042,       // 放回给用户房间的黑名单列表
                SCMD_ROOM_ADD_BLACK_LIST_REQ            = 0x0043,       // 将某用户加入黑名单
                SCMD_ROOM_ADD_BLACK_LIST_RES            = 0x0044,       // 将某用户加入黑名单 返回
                SCMD_ROOM_ADD_BLACK_LIST_NOTIFY_HIM     = 0x0045,       // 将某用户加入黑名单 通知他
                SCMD_ROOM_FIDELITY_SET                  = 0x0046,       // 设置房间音质
                SCMD_ROOM_FIDELITY_SET_RES              = 0x0047,       // 设置房间音质 结果
                SCMD_ROOM_FIDELITY_NOTIFY               = 0x0048,       // 设置房间音质 通知其他用户
                SCMD_ROOM_USER_NUM_REQ                  = 0x0049,       // 用户请求房间内人数
                SCMD_ROOM_USER_NUM_RES                  = 0x004A,       // 服务器返回房间内人数
                SCMD_ROOM_UPDATE_USER_ROLE_REQ          = 0x004B,       // (暂时不用.之后用)
                SCMD_ROOM_UPDATE_USER_ROLE_NOTIFY       = 0x004C,       // 用户的身份变更 通知所有房间用户
                SCMD_ROOM_UPDATE_USER_NICKNAME_NOTIFY   = 0x004D,       // 用户修改昵称后通知所在房间的用户
                SCMD_ROOM_CLEAR_HAND_LIST               = 0x004E,       // 清空举手列表
                SCMD_ROOM_USER_SYSTEM_INFO_REQ          = 0x004F,       // 请求用户系统信息
                SCMD_ROOM_USER_SYSTEM_INFO_RES          = 0x0050,       // 返回用户系统信息
                SCMD_ROOM_ADD_GLOBAL_BLACK_LIST_NOTIFY_HIM      = 0x0051,       // 禁止用户进入所有房间 通知用户
                SCMD_ROOM_REQ_NEW_MEDIA_ADDR            = 0x0052,       // 请求新的MediaServer地址
                SCMD_ROOM_DALABA_SET_REQ                = 0x0053,       // 用户设置大喇叭
                SCMD_ROOM_DALABA_SET_RES                = 0x0054,       // 用户设置大喇叭返回
                SCMD_ROOM_DALABA_DEL_REQ                = 0x0055,       // 用户清空大喇叭
                SCMD_ROOM_DALABA_DEL_RES                = 0x0056,       // 用户清空大喇叭返回结果
                SCMD_ROOM_DALABA_NOTIFY                 = 0x0057,       // 通知用户大喇叭内容
                SCMD_ROOM_VIDEO_REQ_INFO                = 0x005A,       // 请求视频相关信息
                SCMD_ROOM_VIDEO_RES_INFO                = 0x005B,       // 返回视频相关信息结果
                SCMD_ROOM_VIDEO_REQ_START               = 0x005C,       // 请求开启视频
                SCMD_ROOM_VIDEO_RES_START               = 0x005D,       // 返回开启视频结果
                SCMD_ROOM_VIDEO_NOTIFY_START            = 0x005E,       // 通知关闭视频
                SCMD_ROOM_VIDEO_REQ_STOP                = 0x005F,       // 请求关闭视频
                SCMD_ROOM_VIDEO_RES_STOP                = 0x0060,       // 返回关闭视频结果
                SCMD_ROOM_VIDEO_NOTIFY_STOP             = 0x0061,       // 通知关闭视频
                SCMD_ROOM_WHITE_BOARD_REQ_DOC_LINK      = 0x0062,       // 房间用户请求文档下载地址
                SCMD_ROOM_WHITE_BOARD_RES_DOC_LINK      = 0x0063,       // 通知房间用户文档下载地址
                SCMD_ROOM_WHITE_BOARD_SYNC_DOC          = 0x0064,       // 操作者要求同步文档版本
                SCMD_ROOM_WHITE_BOARD_NOTIFY_SYNC_DOC   = 0x0065,       // 通知用户同步版本
                SCMD_ROOM_WHITE_BOARD_ADD_DOC_LINK_RES  = 0x0066,       // 通知操作者添加讲义的结果（失败时返回）
                SCMD_ROOM_USER_OWN_FLOWER_REQ           = 0x0067,       // 请求用户拥有鲜花数
                SCMD_ROOM_USER_OWN_FLOWER_RES           = 0x0068,       // 返回用户拥有鲜花数结果
                SCMD_ROOM_USER_OWN_FLOWER_NOTIFY        = 0x0069,       // 通知用户拥有鲜花数
                SCMD_ROOM_USER_SEND_FLOWER_REQ          = 0x006A,       // 请求用户可送鲜花数
                SCMD_ROOM_USER_SEND_FLOWER_RES          = 0x006B,       // 返回用户可送鲜花数结果
                SCMD_ROOM_USER_SEND_FLOWER_NOTIFY       = 0x006C,       // 通知用户可送鲜花数
                SCMD_ROOM_ADD_SEND_FLOWER_REQ           = 0x006D,       // 请求增加可送鲜花
                SCMD_ROOM_ADD_SEND_FLOWER_RES           = 0x006E,       // 返回增加可送鲜花结果
                SCMD_ROOM_SEND_FLOWER_REQ               = 0x006F,       // 请求赠送鲜花
                SCMD_ROOM_SEND_FLOWER_RES               = 0x0070,       // 返回赠送鲜花结果（如果失败）
                SCMD_ROOM_SEND_FLOWER_NOTIFY            = 0x0071,       // 通知用户赠送鲜花
                SCMD_ROOM_ANSWER_CARD_OPEN_REQ          = 0x0072,       // 打开答题卡
                SCMD_ROOM_ANSWER_CARD_OPEN_RES          = 0x0073,       // 返回打开结果
                SCMD_ROOM_ANSWER_CARD_CLOSE_REQ         = 0x0074,       // 关闭答题卡
                SCMD_ROOM_ANSWER_CARD_CLOSE_RES         = 0x0075,       // 返回关闭结果
                SCMD_ROOM_ANSWER_CARD_STATUS_REQ        = 0x0076,       // 请求答题卡状态
                SCMD_ROOM_ANSWER_CARD_STATUS_RES        = 0x0077,       // 返回答题卡状态
                SCMD_ROOM_ANSWER_CARD_STATUS_NOTIFY     = 0x0078,       // 通知答题卡状态
                SCMD_ROOM_ANSWER_CARD_REQ               = 0x0079,       // 请求操作（答题卡）
                SCMD_ROOM_ANSWER_CARD_RES               = 0x007A,       // 返回操作（答题卡）
                SCMD_ROOM_ANSWER_CARD_NOTIFY            = 0x007B,       // 通知操作（答题卡）
                SCMD_ROOM_TOP_MIC_REQ                   = 0x007C,       // 请求麦序第一人（授课模式下）
                SCMD_ROOM_TOP_MIC_RES                   = 0x007D,       // 返回麦序第一人（授课模式下）
                SCMD_ROOM_WB_ELEMENT_REQ                = 0x007E,       // 请求白板元素
                SCMD_ROOM_WB_ELEMENT_RES                = 0x007F,       // 返回白板元素
                SCMD_ROOM_WB_ELEMENT_ADD                = 0x0080,       // 请求增加白板元素
                SCMD_ROOM_WB_ELEMENT_DEL                = 0x0081,       // 请求擦除白板元素
                SCMD_ROOM_WB_ELEMENT_LASER_PEN          = 0x0082,       // 白板激光笔
                SCMD_ROOM_USER_STATE_LIST_REQ           = 0x0083,       // 请求房间内某个状态的用户列表
                SCMD_ROOM_USER_STATE_LIST_RES           = 0x0084,       // 返回房间内某个状态的用户列表
                SCMD_ROOM_CLASS_EVAL_TIME_NOTIFY        = 0x0085,       // 课程评价弹出时间通知
                SCMD_ROOM_QUESTION_LIST_REQ             = 0x0086,       // 请求问题列表
                SCMD_ROOM_QUESTION_LIST_RES             = 0x0087,       // 返回问题列表
                SCMD_ROOM_ASK_QUESTION_REQ              = 0x0088,       // 请求提出问题
                SCMD_ROOM_ASK_QUESTION_RES              = 0x0089,       // 返回提出问题结果
                SCMD_ROOM_ASK_QUESTION_NOTIFY           = 0x008A,       // 通知提出问题
                SCMD_ROOM_LIKE_QUESTION_REQ             = 0x008B,       // 请求同问
                SCMD_ROOM_LIKE_QUESTION_RES             = 0x008C,       // 返回同问结果
                SCMD_ROOM_LIKE_QUESTION_NOTIFY          = 0x008D,       // 通知同问
                SCMD_ROOM_MODIFY_QUESTION_REQ           = 0x008E,       // 请求修改问题
                SCMD_ROOM_MODIFY_QUESTION_RES           = 0x008F,       // 返回修改问题结果
                SCMD_ROOM_MODIFY_QUESTION_NOTIFY        = 0x0090,       // 通知修改问题
                SCMD_ROOM_CLASS_INFO_REQ                = 0x0091,       // 用户请求当前授课的老师
                SCMD_ROOM_CLASS_INFO_RES                = 0x0092,       // 返回给用户当前授课的老师
                SCMD_ROOM_QUESTION_LIKE_LIST_REQ        = 0x0093,       // 请求喜欢问题列表
                SCMD_ROOM_QUESTION_LIKE_LIST_RES        = 0x0094,       // 返回喜欢问题列表
                SCMD_ROOM_JOIN                          = 0x0095,	// 进入房间
                SCMD_ROOM_REQ_USER_LIST                 = 0x0096,	// 请求方将用户列表
                SCMD_ROOM_RES_USER_LIST                 = 0x0097,	// 返回房间用户列表
                SCMD_ROOM_REQ_CLASS_BEGIN               = 0x0098,	// 上课
                SCMD_ROOM_RES_CLASS_BEGIN               = 0x0099,	// 上课结果
                SCMD_ROOM_NOTIFY_CLASS_BEGIN            = 0x009A,	// 通知上课
                SCMD_ROOM_REQ_CLASS_END                 = 0x009B,	// 下课
                SCMD_ROOM_RES_CLASS_END                 = 0x009C,	// 下课结果
                SCMD_ROOM_NOTIFY_CLASS_END              = 0x009D,	// 通知下课
                SCMD_ROOM_REQ_CLASS_END_FORCE           = 0x009E,       // 强制下课
                SCMD_ROOM_RES_CLASS_END_FORCE           = 0x009F,       // 强制下课结果
                SCMD_ROOM_NOTIFY_CLASS_END_FORCE        = 0x00A0,       // 强制下课通知
                SCMD_ROOM_CONTROL_STATUS_SET            = 0x00A1,       // 用户请求设置某些房间的控制状态
                SCMD_ROOM_NOTIFY_JOIN                   = 0x00A2,       // 进入房间 通知房间内用户
                SCMD_ROOM_SPEAK_USERS_REQ               = 0x00A3,       // 请求房间用户当前可以说话的用户
                SCMD_ROOM_SPEAK_USERS_RES               = 0x00A4,       // 返回房间用户当前可以说话的用户              
                SCMD_ROOM_DALABA_REQ                    = 0x00A5,       // 请求用户大喇叭内容
                SCMD_ROOM_CLASS_EVAL_TIME_REQ           = 0x00A6,       // 请求课程评价弹出时间
                SCMD_ROOM_BASE_INFO_REQ                 = 0x00A7,	// 请求房间基本信息
                SCMD_ROOM_BASE_INFO_RES                 = 0x00A8,	// 返回房间基本信息
                SCMD_ROOM_REQ_USER_ID_LIST              = 0x00A9,	// 请求房间用户ID列表
                SCMD_ROOM_RES_USER_ID_LIST              = 0x00AA,	// 返回房间用户ID列表
                SCMD_ROOM_REQ_MUTE_MEDIA_DATA           = 0x00AB,	// 禁止/允许用户媒体数据请求
                SCMD_ROOM_RES_MUTE_MEDIA_DATA           = 0x00AC,	// 禁止/允许用户媒体数据应答
                SCMD_ROOM_REQ_USER_INFO_LIST            = 0x00AD,	// 请求房间用户详细信息列表
                SCMD_ROOM_RES_USER_INFO_LIST            = 0x00AE,	// 返回房间用户详细信息列表应答.
                SCMD_ROOM_NOTIFY_CHANGE_MODE_NEW        = 0x00AF,       // 上下课状态变化通知
                SCMD_ROOM_ANOTHER_MEDIA_ADDR_REQ        = 0x00B0,       // 重新请求Media地址
                SCMD_ROOM_ANOTHER_MEDIA_ADDR_RET        = 0x00B1,       // 返回请求Media地址
        };

        struct stRoomJoin_old :
                stRoomCmd
        {
                stRoomJoin_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_JOIN_old)
                {
                        with_password_ = 0;
                        bzero(password_, sizeof(password_));
                }
                BYTE  with_password_;		//0-no, 1-yes   // 是否携带密码
                BYTE password_[MAX_PASSWORD_SIZE+1];            // 密码
        };
        struct stRoomJoinRes :
                stRoomCmd
        {
                stRoomJoinRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_JOIN_RES)
                {
                        ret_code_ = eJoinRoomRet_Fail;
                }
                BYTE ret_code_;			//eJoinRoomRet  // 进入房间结果
        };
        struct stRoomNotifyJoin_old:
                stRoomCmd
        {
                stRoomNotifyJoin_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_JOIN_old)
                {
                        user_id_ = 0;
                        bzero(user_name_, sizeof(user_name_));
                        bzero(nick_name_, sizeof(nick_name_));
                        state_ = USER_STATE_ONLINE;
                        show_identity_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
                char user_name_[MAX_ACCOUNT_SIZE+1];            // 用户帐号
                char nick_name_[MAX_NAME_SIZE+1];               // 用户昵称
                BYTE state_; //eIMOnlineStatus                  // 在线状态
                uint8_t show_identity_;                         // 身份
        };
        struct stRoomLeave :
                stRoomCmd
        {
                stRoomLeave():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_LEAVE)
                {
                }
        };
        struct stRoomNotifyLeave:
                stRoomCmd
        {
                stRoomNotifyLeave():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_LEAVE)
                {
                        user_id_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomChatSend :
                stRoomCmd
        {
                stRoomChatSend():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CHAT_SEND)
                {
                        msg_type_ = 0;
                        size_ = 0;
                }
                BYTE  msg_type_;    //eChatMsgType              // 消息类型
                WORD size_;                                     // 消息长度
                char chat_msg_[0];                              // 消息内容
                DWORD getSize() const 
                { 
                        return sizeof(*this)+size_*sizeof(chat_msg_[0]); 
                }
        };
        struct stRoomChatRecv
                : stRoomCmd
        {
                stRoomChatRecv():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CHAT_RECV)
                {
                        msg_type_ = 0;
                        sender_ = 0;
                        time_ = 0;
                        size_ = 0;
                }
                BYTE  msg_type_;    //eChatMsgType              // 消息类型
                DWORD sender_;                                  // 发送者ID
                DWORD time_;                                    // 发送时间
                WORD size_;                                     // 消息长度
                char chat_msg_[0];                              // 消息内容
                DWORD getSize() const 
                { 
                        return sizeof(*this)+size_*sizeof(chat_msg_[0]); 
                }
        };
        struct stRoomReqBaseInfo_old :
                stRoomCmd
        {
                stRoomReqBaseInfo_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_BASE_INFO_old)
                {
                }
        };
        struct stRoomResBaseInfo_old :
                stRoomCmd
        {
                stRoomResBaseInfo_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_BASE_INFO_old)
                {
                        mode_ = eRoomMode_Dialog;
                        bzero(name_, sizeof(name_));
                        mic_time_ = DEFAULT_MIC_TIME;
                        fidelity_ = 0;
                }
                BYTE mode_; //eRoomMode                         // 房间模式
                char name_[MAX_ROOM_NAME_SIZE+1];               // 房间名称
                WORD mic_time_;                                 // 麦序时间
                BYTE fidelity_; //0-high 1-middle 2-low         // 音质模式
                //...
        };
        struct stRoomResAddrInfo :
                stRoomCmd
        {
                stRoomResAddrInfo():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_ADDR_INFO)
                {
                        ip_ = 0;
                        port_ = 0;
                }
                DWORD ip_;                                      // RoomMedia IP
                WORD port_;                                     // RoomMedia Port
        };
        struct stRoomReqUserList_old :
                stRoomCmd
        {
                stRoomReqUserList_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_USER_LIST_old)
                {
                }
        };
        struct stRoomResUserList_old :
                stRoomCmd
        {
                stRoomResUserList_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_USER_LIST_old)
                {
                        size_ = 0;
                        finish_ = 0;
                }
                WORD size_;                                     // 列表大小
                BYTE finish_; //0-no ,1-yes                     // 是否结束标记
                struct stRUL {
                        DWORD user_id_;                         // 用户ID
                        char user_name_[MAX_ACCOUNT_SIZE+1];    // 用户帐号
                        char nick_name_[MAX_NAME_SIZE+1];       // 用户昵称
                        BYTE show_identity_;                    // 用户身份
                } list_[0];
                DWORD getSize()
                {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
        };
        struct stRoomReqMicQueue :
                stRoomCmd
        {
                stRoomReqMicQueue():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_MIC_QUEUE)
                {
                }
        };
        struct stRoomResMicQueue :
                stRoomCmd
        {
                stRoomResMicQueue():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_MIC_QUEUE)
                {
                        size_ = 0;
                }
                WORD size_;                                     // 麦序列表大小
                struct stMQ {
                        BYTE index;	                        // 麦序位置
                        DWORD userid;	                        // 用户ID
                } list_[0];
                DWORD getSize()
                {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
        };
        struct stRoomReqHandupList :
                stRoomCmd
        {
                stRoomReqHandupList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_HANDUP_LIST)
                {
                }
        };
        struct stRoomResHandupList :
                stRoomCmd
        {
                stRoomResHandupList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_HANDUP_LIST)
                {
                        size_ = 0;
                }
                WORD size_;                                     // 举手列表大小
                DWORD list_[0];                                 // 举手列表
                DWORD getSize()
                {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
        };
        struct stRoomJoinInfoEnd :
                stRoomCmd
        {
                stRoomJoinInfoEnd():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_JOIN_INFO_END)
                {
                }
        };
        struct stRoomReqManagerList:
                stRoomCmd
        {
                stRoomReqManagerList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_MANAGER_LIST)
                {
                }
        };
        struct stRoomResManagerList:
                stRoomCmd
        {
                stRoomResManagerList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_MANAGER_LIST)
                {
                        size_ = 0;
                }
                WORD size_;                                     // 管理员列表大小
                struct stML{
                        DWORD manager_id_;                      // 管理员ID
                        BYTE power_; //eRoomAuthority           // 权限类型
                } list_[0];
                DWORD getSize()
                {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
        };
        struct stRoomReqChangeMode:
                stRoomCmd
        {
                stRoomReqChangeMode():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_CHANGE_MODE)
                {
                        mode_ = eRoomMode_Dialog;
                }
                BYTE mode_; //eRoomMode                         // 房间模式（上下课状态）
        };
        struct stRoomResChangeMode:
                stRoomCmd
        {
                stRoomResChangeMode():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_CHANGE_MODE)
                {
                        mode_ = eRoomMode_Dialog;
                        ret_code_ = 0;
                }
                BYTE mode_;		//eRoomMode             // 房间模式
                BYTE ret_code_; 	//0-fail,1-success,2-power limit, 3-same mode   // 上下课结果
        };
        struct stRoomNotifyChangeMode:
                stRoomCmd
        {
                stRoomNotifyChangeMode():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_CHANGE_MODE)
                {
                        operator_ = 0;
                        mode_ = eRoomMode_Dialog;
                }
                DWORD operator_;                                // 操作者ID
                BYTE mode_;                                     // 房间模式
        };
        struct stRoomJoinMicQueue:
                stRoomCmd
        {
                stRoomJoinMicQueue():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_JOIN_MIC_QUEUE)
                {
                }
        };
        struct stRoomJoinMicQueueRes:
                stRoomCmd
        {
                stRoomJoinMicQueueRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_JOIN_MIC_QUEUE_RES)
                {
                        index_ = 0;
                        ret_code_ = 0;
                }
                BYTE index_;	//0为1号麦                      // 麦序位置
                BYTE ret_code_; //0-fail, 1-success, 2-queue full, 3-invalid mode, 4-repeat req         // 加入麦序结果
        };
        struct stRoomNotifyJoinMicQueue:
                stRoomCmd
        {
                stRoomNotifyJoinMicQueue():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_JOIN_MIC_QUEUE)
                {
                        user_id_ = 0;
                        index_   = 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE index_;	//0为1号麦                      // 麦序位置
        };
        struct stRoomLeaveMicQueue:
                stRoomCmd
        {
                stRoomLeaveMicQueue():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_LEAVE_MIC_QUEUE)
                {
                }
        };
        struct stRoomLeaveMicQueueRes:
                stRoomCmd
        {
                stRoomLeaveMicQueueRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_LEAVE_MIC_QUEUE_RES)
                {
                        ret_code_= 0;
                }
                BYTE ret_code_; //0-fail, 1-success 2-user not in mic queue     // 离开麦序结果
        };
        struct stRoomNotifyLeaveMicQueue:
                stRoomCmd
        {
                stRoomNotifyLeaveMicQueue():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_LEAVE_MIC_QUEUE)
                {
                        user_id_ = 0;
                }
                DWORD user_id_; //下麦用户                      // 用户ID
        };
        struct stRoomHandUp:
                stRoomCmd
        {
                stRoomHandUp():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_HAND_UP)
                {
                }
        };
        struct stRoomHandUpRes:
                stRoomCmd
        {
                stRoomHandUpRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_HAND_UP_RES)
                {
                        index_ = 0;
                        ret_code_= 0;
                }
                BYTE index_;	//0为1号举手者                  // 举手列表位置
                BYTE ret_code_; //0-fail, 1-success, 2-list full, 3-invalid mode        // 举手结果
        };
        struct stRoomNotifyHandUp:
                stRoomCmd
        {
                stRoomNotifyHandUp():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_HAND_UP)
                {
                        user_id_ = 0;
                        index_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE index_;                                    // 举手列表位置
        };
        struct stRoomHandOff:
                stRoomCmd
        {
                stRoomHandOff():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_HAND_OFF)
                {
                }
        };
        struct stRoomHandOffRes:
                stRoomCmd
        {
                stRoomHandOffRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_HAND_OFF_RES)
                {
                        ret_code_= 0;
                }
                BYTE ret_code_; //0-fail, 1-success             // 放手结果
        };
        struct stRoomNotifyHandOff:
                stRoomCmd
        {
                stRoomNotifyHandOff():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_HAND_OFF)
                {
                        user_id_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomAddUserToMic:
                stRoomCmd
        {
                stRoomAddUserToMic():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_USER_TO_MIC)
                {
                        manager_id_ = 0;
                        user_id_ = 0;
                }
                DWORD manager_id_;                              // 管理员ID
                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomAddUserToMicRes:
                stRoomCmd
        {
                stRoomAddUserToMicRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_USER_TO_MIC_RES)
                {
                        manager_id_ = 0;
                        user_id_ = 0;
                        accept_ = 0;
                        ret_code_ =0;
                }
                DWORD manager_id_;                              // 管理员ID
                DWORD user_id_;                                 // 用户ID
                BYTE accept_;  //0-deny 1-accept                // 是否同意
                BYTE ret_code_; //0-fail 1-success 2-mic queue full 3-invalid mode 4-user deny 5-in talk 6-in p2p voice chat    // 加入麦序结果
        };
        struct stRoomNotifyAddUserToMic:
                stRoomCmd
        {
                stRoomNotifyAddUserToMic():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_ADD_USER_TO_MIC)
                {
                        manager_ = 0;
                        user_id_ = 0;
                        index_ = 0;
                }
                DWORD manager_;                                 // 管理员ID
                DWORD user_id_;                                 // 用户ID
                BYTE  index_; //0为1号麦序                      // 麦序列表位置
        };
        struct stRoomRemoveUserFromMic:
                stRoomCmd
        {
                stRoomRemoveUserFromMic():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REMOVE_USER_FROM_MIC)
                {
                        user_id_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomRemoveUserFromMicRes:
                stRoomCmd
        {
                stRoomRemoveUserFromMicRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REMOVE_USER_FROM_MIC_RES)
                {
                        user_id_ = 0;
                        ret_code_= 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE ret_code_; //0-fail, 1-success, 2-invalid power    // 移除麦序结果
        };
        struct stRoomRemoveUserFromMicNotify:
                stRoomCmd
        {
                stRoomRemoveUserFromMicNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REMOVE_USER_FROM_MIC_NOTIFY)
                {
                        manager_ = 0;
                        user_id_ = 0;
                }
                DWORD manager_;                                 // 管理员ID
                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomReqAppBitMask:
                stRoomCmd
        {
                stRoomReqAppBitMask():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_APP_BIT_MASK)
                {
                }
        };
        struct stRoomResAppBitMask:
                stRoomCmd
        {
                stRoomResAppBitMask():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_APP_BIT_MASK)
                {
                        bit_mask_ = 0;
                }
                DWORD bit_mask_; //按位表示. eRoomAppBitMask    // 房间应用
        };
        struct stRoomWhiteBoardAddDocLinkReq:
                stRoomCmd
        {
                stRoomWhiteBoardAddDocLinkReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_ADD_DOC_LINK_REQ)
                {
                        cur_page_ = 0;
                        size_ = 0;
                }
                BYTE cur_page_;
                WORD size_;
                char link_[0];
                DWORD getSize()
                {
                        return sizeof(*this)+size_*sizeof(link_[0]);
                }
        };
        struct stRoomWhiteBoardReqDocLink_old:
                stRoomCmd
        {
                stRoomWhiteBoardReqDocLink_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_REQ_DOC_LINK_old)
                {
                }
        };
        struct stRoomWhiteBoardResDocLink_old:
                stRoomCmd
        {
                stRoomWhiteBoardResDocLink_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_RES_DOC_LINK_old)
                {
                        cur_page_ = 0;
                        size_ = 0;
                }
                BYTE cur_page_;                                 // 当前页码
                WORD size_;                                     // 链接大小
                char link_[0];                                  // 链接
                DWORD getSize()
                {
                        return sizeof(*this)+size_*sizeof(link_[0]);
                }
        };
        struct stRoomWhiteBoardDelDocLink:
                stRoomCmd
        {
                stRoomWhiteBoardDelDocLink():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_DEL_DOC_LINK)
                {
                        doc_id_ = 0;
                        operator_id_ = 0;
                }
                DWORD doc_id_;                                  // PPT ID(client fill)
                DWORD operator_id_;                             // 操作者ID(为了客户端方便)
        };

        //定义图形基本属性
        struct stShapeBaseInfo
        {
                stShapeBaseInfo()
                {
                        type = eRoomWhiteBoardShapeType_null;
                        diameter = 0;
                        color = 0;
                }
                BYTE type;                                      // 类型. eRoomWhiteBoardShapeType
                BYTE diameter;                                  // 画笔直径
                DWORD color;                                    // 画笔颜色
        };
        //定义图形属性
        struct stShapeInfo:
                stShapeBaseInfo
        {
                stShapeInfo()
                {
                        id = 0;
                        point_num = 0;
                }
                DWORD id;                                       // 图形ID
                DWORD point_num;                                // 点的个数
                st2DCoordinate point_list[0];
                DWORD getSize()
                {
                        return sizeof(*this)+point_num*sizeof(point_list[0]);
                }
        };
        //请求白板笔记
        struct stRoomWhiteBoardReqInfo:
                stRoomCmd
        {
                stRoomWhiteBoardReqInfo():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_REQ_INFO)
                {
                        page_ = 0;
                }
                SWORD page_;    //-1:current page               // 页码
        };
        //返回白板笔记-图形
        struct stRoomWhiteBoardResShape:
                stRoomCmd
        {
                stRoomWhiteBoardResShape():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_RES_SHAPE)
                {
                        page_ = 0;
                        num_ = 0;
                        data_len_ = 0;
                }
                SWORD page_;                                    // 页码
                WORD  num_;                                     // data_中的图形的个数
                DWORD data_len_;                                // data_的长度
                BYTE data_[0];                                  // 多个不同长度的 stShapeInfo
                DWORD getSize()
                {
                        return sizeof(*this)+data_len_*sizeof(data_[0]);
                }
        };
        //返回白板笔记-文字
        struct stRoomWhiteBoardResText:
                stRoomCmd
        {
                stRoomWhiteBoardResText():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_RES_TEXT)
                {
                        page_ = -1;
                        id_ = 0;
                        text_len_ = 0;
                }
                SWORD page_;                                    // 页码
                WORD id_;                                       // 对象ID
                stShapeBaseInfo base_info_;                     // 文本基本属性
                st2DCoordinate points_[2];                      // 文本坐标
                WORD text_len_;                                 // 文本长度
                BYTE text_[0];                                  // 文本内容
                DWORD getSize()
                {
                        return sizeof(*this)+text_len_*sizeof(text_[0]); 
                }
        };
        //增加形状笔记
        struct stRoomWhiteBoardAddShape:
                stRoomCmd
        {
                stRoomWhiteBoardAddShape():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_ADD_SHAPE)
                {
                        page_ = 0;
                        point_num_ = 0;
                        id_ = 0;
                }
                SWORD page_;                                    // 页码
                WORD id_;                                       // 对象ID
                stShapeBaseInfo base_info_;                     // 基本信息
                WORD point_num_;                                // 点的个数
                st2DCoordinate point_list_[0];                  // 点列表
                DWORD getSize()
                {
                        return sizeof(*this)+point_num_*sizeof(point_list_[0]);
                }
        };
        //增加文字笔记
        struct stRoomWhiteBoardAddText:
                stRoomCmd
        {
                stRoomWhiteBoardAddText():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_ADD_TEXT)
                {
                        page_ = 0;
                        id_ = 0;
                        text_len_ = 0;
                }
                SWORD page_;                                    // 页码
                WORD id_;                                       // 对象ID
                stShapeBaseInfo base_info_;                     // 文本基本属性
                st2DCoordinate points_[2];                      // 文本坐标
                WORD text_len_;                                 // 文本长度
                BYTE text_[0];                                  // 文本内容
                DWORD getSize()
                {
                        return sizeof(*this)+text_len_*sizeof(text_[0]);
                }
        };
        //擦除某条笔记
        struct stRoomWhiteBoardEraseElement:
                stRoomCmd
        {
                stRoomWhiteBoardEraseElement():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_ERASE_ELEMENT)
                {
                        page_ = 0;
                        id_ = 0;
                }
                SWORD page_;                                    // 页码
                WORD id_;                                       // 对象ID
        };
        //清空白板笔记
        struct stRoomWhiteBoardClear:
                stRoomCmd
        {
                stRoomWhiteBoardClear():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_CLEAR)
                {
                        page_ = 0;
                }
                SWORD page_;                                    // 页码
        };
        //白板/讲义翻页
        struct stRoomWhiteBoardPage:
                stRoomCmd
        {
                stRoomWhiteBoardPage():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_PAGE)
                {
                        page_ = 1;
                        operator_id_ = 0;
                }
                SWORD page_;                                    // 翻页到第page_页
                DWORD operator_id_;                             // 操作者ID（为了客户端方便）
        };
        //光标位置
        struct stRoomWhiteBoardCursor:
                stRoomCmd
        {
                stRoomWhiteBoardCursor():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_CURSOR)
                {
                }
                st2DCoordinate cursor_;                         // 光标位置
        };
        //请求房间的显示信息
        struct stRoomReqShowInfo:
                stRoomCmd
        {
                stRoomReqShowInfo():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_SHOW_INFO)
                {
                }
        };
        //返回房间的显示信息
        struct stRoomResShowInfo:
                stRoomCmd
        {
                stRoomResShowInfo():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_SHOW_INFO)
                {
                        bzero(name_, sizeof(name_));
                        bzero(avatar_, sizeof(avatar_));
                        user_num_ = 0;
                }
                char name_[MAX_ROOM_NAME_SIZE+1];               // 房间名称
                char avatar_[MAX_AVATAR_SIZE+1];                // 房间图标地址
                WORD user_num_;                                 // 房间人数
        };
        //设置用户的伪装身份
        //只有管理员权限的用户可以设置
        struct stRoomSetUserShowIdentity:
                stRoomCmd
        {
                stRoomSetUserShowIdentity():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_SET_USER_SHOW_IDENTITY)
                {
                        user_id_ = 0;
                        show_identity_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE show_identity_;                            // 身份类型
        };
        struct stRoomControlStatusSet_old:
                stRoomCmd
        {
                stRoomControlStatusSet_old():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CONTROL_STATUS_SET_old)
                {
                        control_status_ = 0;
                }
                DWORD control_status_;                          // 禁用状态(按位表示,每位属性参考eRoomControlStatusType)
        };
        struct stRoomControlStatusSetRes:
                stRoomCmd
        {
                stRoomControlStatusSetRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CONTROL_STATUS_SET_RES)
                {
                        control_status_ = 0;
                }
                DWORD control_status_;                          // 禁用状态(按位表示,每位属性参考eRoomControlStatusType)
                BYTE  ret_code_;        //0-fail 1-success      // 设置禁用状态结果
        };
        struct stRoomControlStatusNotify:
                stRoomCmd
        {
                stRoomControlStatusNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CONTROL_STATUS_NOTIFY)
                {
                        control_status_ = 0;
                }
                DWORD control_status_;                          // 禁用状态(按位表示,每位属性参考eRoomControlStatusType)
        };
        struct stRoomUpdateMicTime:
                stRoomCmd
        {
                stRoomUpdateMicTime():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_UPDATE_MIC_TIME)
                {
                        user_id_ = 0;
                        mic_time_ = DEFAULT_MIC_TIME;
                }
                DWORD user_id_;                                 // 操作者ID
                WORD mic_time_;                                 // 麦序时间(大于MIN_MIC_TIME 且 小于MAX_MIC_TIME))
        };
        struct stRoomNotifySpeakUsers:
                stRoomCmd
        {
                stRoomNotifySpeakUsers():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_SPEAK_USERS)
                {
                        user_num_ = 0;
                }
                WORD user_num_;                                 // 说话列表大小
                struct stSpeakInfo{
                        DWORD userid;                           // 用户ID
                        DWORD time;	                        // 已经说话的时长
                        BYTE timetype;	                        // 时间计时方式:0-dec, 1-inc
                } user_list_[0];
                DWORD getSize() {
                        return sizeof(*this)+user_num_*sizeof(user_list_[0]);
                }
        };
        struct stRoomBlackListReq:
                stRoomCmd
        {
                stRoomBlackListReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_BLACK_LIST_REQ)
                {
                }
        };
        struct stRoomBlackListRes:
                stRoomCmd
        {
                stRoomBlackListRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_BLACK_LIST_RES)
                {
                }
        };
        struct stRoomAddBlackListReq:
                stRoomCmd
        {
                stRoomAddBlackListReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_BLACK_LIST_REQ)
                {
                        user_id_ = 0;
                        minutes_ = 120;
                        bzero(reason_, sizeof(reason_));
                }
                DWORD user_id_;                                 // 用户ID
                DWORD minutes_; //分钟:默认120m, 1~999          // 禁用时间
                char reason_[MAX_ADD_ROOM_BLACK_REASON+1];      // 禁用原因
        };
        struct stRoomAddBlackListRes:
                stRoomCmd
        {
                stRoomAddBlackListRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_BLACK_LIST_RES)
                {
                        user_id_ = 0;
                        minutes_ = 120;
                        ret_code_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
                DWORD minutes_;                                 // 禁用时间
                BYTE ret_code_; //0-fail 1-success              // 禁用结果
        };
        struct stRoomAddBlackListNotifyHim:
                stRoomCmd
        {
                stRoomAddBlackListNotifyHim():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_BLACK_LIST_NOTIFY_HIM)
                {
                        manager_ = 0;
                        minutes_ = 120;
                        bzero(reason_, sizeof(reason_));
                }
                DWORD manager_;                                 // 操作者ID
                DWORD minutes_;                                 // 禁用时间
                char reason_[MAX_ADD_ROOM_BLACK_REASON+1];      // 禁用原因
        };
        struct stRoomFidelitySet:
                stRoomCmd
        {
                stRoomFidelitySet():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_FIDELITY_SET)
                {
                        fidelity_ = 0;
                }
                BYTE fidelity_;                                 // 音质模式
        };
        struct stRoomFidelitySetRes:
                stRoomCmd
        {
                stRoomFidelitySetRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_FIDELITY_SET_RES)
                {
                        fidelity_ = 0;
                        ret_code_ = 0;
                }
                BYTE fidelity_;                                 // 音质模式
                BYTE ret_code_; //0-fail 1-success              // 设置音质模式结果
        };
        struct stRoomFidelityNotify:
                stRoomCmd
        {
                stRoomFidelityNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_FIDELITY_NOTIFY)
                {
                        fidelity_ = 0;
                }
                BYTE fidelity_;                                 // 音质模式
        };
        struct stRoomUserNumReq:
                stRoomCmd
        {
                stRoomUserNumReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_NUM_REQ)
                {
                        size_ = 0;
                }
                WORD size_;                                     // 用户列表大小
                DWORD list_[0];                                 // 用户列表
                DWORD getSize() {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
        };
        struct stRoomUserNumRes:
                stRoomCmd
        {
                stRoomUserNumRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_NUM_RES)
                {
                        finish_ = 0;
                        size_ = 0;
                }
                BYTE finish_; //0-not finish; 1-finish          // 是否结束标记
                WORD size_;                                     // 用户列表大小
                struct stRoomUserNum{
                        DWORD roomid;                           // 房间ID
                        DWORD usernum;                          // 用户数量
                } list_[0];
                DWORD getSize() {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
        };
        struct stRoomUpdateUserRoleNotify:
                stRoomCmd
        {
                stRoomUpdateUserRoleNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_UPDATE_USER_ROLE_NOTIFY)
                {
                        user_id_ = 0;
                        user_role_ = 0;
                }
                DWORD user_id_;                                 // 用户ID
                BYTE user_role_; //eRoomAuthority               // 权限类型
        };

        struct stRoomUpdateUserNickNameNotify:
                stRoomCmd
        {
                stRoomUpdateUserNickNameNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_UPDATE_USER_NICKNAME_NOTIFY)
                {
                        user_id_ = 0;
                        bzero(nick_name_, sizeof(nick_name_));
                }
                DWORD user_id_;                                 // 用户ID
                char nick_name_[MAX_NAME_SIZE+1];               // 用户昵称
        };
        struct stRoomClearHandList:
                stRoomCmd
        {
                stRoomClearHandList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CLEAR_HAND_LIST)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 清空举手列表结果
        };
        struct stRoomUserSystemInfoReq:
                stRoomCmd
        {
                stRoomUserSystemInfoReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_SYSTEM_INFO_REQ)
                {
                        requestor_ = 0;
                        answer_ = 0;
                }
                DWORD requestor_;                               // 请求者ID
                DWORD answer_;                                  // 被查看用户ID
        };
        struct stRoomUserSystemInfoRes:
                stRoomCmd
        {
                stRoomUserSystemInfoRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_SYSTEM_INFO_RES)
                {
                        requestor_ = 0;
                        answer_ = 0;
                        size_ = 0;
                }
                DWORD requestor_;                               // 请求者ID
                DWORD answer_;                                  // 被查看用户ID
                DWORD size_;                                    // 系统信息大小
                char info_[0];                                  // 系统信息
                DWORD getSize() {
                        return sizeof(*this)+size_*sizeof(info_[0]);
                }

        };
        struct stRoomAddGlobalBlackListNotifyHim:
                stRoomCmd
        {
                stRoomAddGlobalBlackListNotifyHim():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_GLOBAL_BLACK_LIST_NOTIFY_HIM)
                {
                        minutes_ = 0;
                        bzero(reason_, sizeof(reason_));
                }
                DWORD minutes_;                                 // 禁用时间
                char reason_[256];                              // 禁用原因
        };
        struct stRoomReqNewMediaAddr:
                stRoomCmd
        {
                stRoomReqNewMediaAddr():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_NEW_MEDIA_ADDR)
                {
                }
        };
        struct stRoomDalabaSetReq:
                stRoomCmd
        {
                stRoomDalabaSetReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_DALABA_SET_REQ)
                {
                        len_ = 0;
                }
                WORD len_;                                      // 大喇叭内容大小
                char laba_[0];                                  // 大喇叭内容
                DWORD getSize()
                {
                        return sizeof(*this) + len_*sizeof(laba_[0]);
                }
        };
        struct stRoomDalabaSetRes:
                stRoomCmd
        {
                stRoomDalabaSetRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_DALABA_SET_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_;                                 // 大喇叭设置结果
        };
        struct stRoomDalabaDelReq:
                stRoomCmd
        {
                stRoomDalabaDelReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_DALABA_DEL_REQ)
                {
                }
        };
        struct stRoomDalabaDelRes:
                stRoomCmd
        {
                stRoomDalabaDelRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_DALABA_DEL_RES)
                {
                        ret_code_ = 0;
                }
                BYTE ret_code_; //0-fail 1-success              // 删除大喇叭结果
        };
        struct stRoomDalabaNotify:
                stRoomCmd
        {
                stRoomDalabaNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_DALABA_NOTIFY)
                {
                        len_ = 0;
                }
                WORD len_;                                      // 大喇叭长度
                char laba_[0];                                  // 大喇叭内容
                DWORD getSize()
                {
                        return sizeof(*this) + len_*sizeof(laba_[0]);
                }
        };
        struct stRoomVideoReqInfo:
                stRoomCmd
        {
                stRoomVideoReqInfo():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_REQ_INFO)
                {
                        video_type_ = eRoomVideoType_Null;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
        };
        struct stRoomVideoResInfo:
                stRoomCmd
        {
                stRoomVideoResInfo():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_RES_INFO)
                {
                        video_type_ = 0;
                        ret_code_ = 0;
                        size_ = 0;
                }

                DWORD getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                BYTE video_type_;                               // 见:eRoomVideoType
                BYTE ret_code_;                                 // 请求结果：0成功 非0失败
                WORD size_;
                char json_[0];
                // json_ = video_info(value) + video_user_info(value)
                // video_info = resolution_x(uint) + resolution_y(uint) + frame_rate(uint) + bit_rate(uint) + codec_index(uint)
                // video_user_info = user_limit(uint) + video_users(value)
                // video_users = video_user(value)...
                // video_user = user_id(uint)
        };
        struct stRoomVideoReqStart:
                stRoomCmd
        {
                stRoomVideoReqStart():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_REQ_START)
                {
                        video_type_ = eRoomVideoType_Null;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
        };
        struct stRoomVideoResStart:
                stRoomCmd
        {
                stRoomVideoResStart():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_RES_START)
                {
                        video_type_ = eRoomVideoType_Null;
                        ret_code_ = 0;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
                BYTE ret_code_;                                 // 开启结果：0成功 1没有权限 2已达上限 3重复开启 4未知类型 5开启冲突
        };
        struct stRoomVideoNotifyStart:
                stRoomCmd
        {
                stRoomVideoNotifyStart():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_NOTIFY_START)
                {
                        video_type_ = eRoomVideoType_Null;
                        user_id_ = 0;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
                DWORD user_id_;                                 // 开启视频用户ID
        };
        struct stRoomVideoReqStop:
                stRoomCmd
        {
                stRoomVideoReqStop():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_REQ_STOP)
                {
                        video_type_ = eRoomVideoType_Null;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
        };
        struct stRoomVideoResStop:
                stRoomCmd
        {
                stRoomVideoResStop():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_RES_STOP)
                {
                        video_type_ = eRoomVideoType_Null;
                        ret_code_ = 0;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
                BYTE ret_code_;                                 // 关闭结果：0成功 1不曾开启 2未知类型
        };
        struct stRoomVideoNotifyStop:
                stRoomCmd
        {
                stRoomVideoNotifyStop():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_VIDEO_NOTIFY_STOP)
                {
                        video_type_ = eRoomVideoType_Null;
                        user_id_ = 0;
                }

                BYTE video_type_;                               // 见:eRoomVideoType
                DWORD user_id_;                                 // 结束视频用户ID
        };
        struct stRoomWhiteBoardReqDocLink:
                stRoomCmd
        {
                stRoomWhiteBoardReqDocLink():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_REQ_DOC_LINK)
                {
                }
        };
        struct stRoomWhiteBoardResDocLink:
                stRoomCmd
        {
                stRoomWhiteBoardResDocLink():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_RES_DOC_LINK)
                {
                        operator_id_ = 0;
                        cur_version_ = 0;
                        cur_page_ = 0;
                        size_ = 0;
                }

                DWORD getSize() const
                {
                        return sizeof(*this)+size_*sizeof(link_[0]);
                }

                DWORD operator_id_;                             // 操作者ID
                DWORD cur_version_;                             // 当前版本号
                BYTE cur_page_;                                 // 当前页码
                WORD size_;                                     // 链接长度
                char link_[0];                                  // 链接地址
        };
        struct stRoomWhiteBoardSyncDoc:
                stRoomCmd
        {
                stRoomWhiteBoardSyncDoc():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_SYNC_DOC)
                {
                }
        };
        struct stRoomWhiteBoardNotifySyncDoc:
                stRoomCmd
        {
                stRoomWhiteBoardNotifySyncDoc():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_NOTIFY_SYNC_DOC)
                {
                        cur_version_ = 0;
                        operator_id_ = 0;
                }

                DWORD cur_version_;                             // 当前版本号
                DWORD operator_id_;                             // 操作者ID(为了客户端方便)
        };
        struct stRoomWhiteBoardAddDocLinkRes:
                stRoomCmd
        {
                stRoomWhiteBoardAddDocLinkRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_WHITE_BOARD_ADD_DOC_LINK_RES)
                {
                        ret_code_ = 0;
                        operator_id_ = 0;
                        cur_version_ = 0;
                        cur_page_ = 0;
                        size_ = 0;
                }

                DWORD getSize() const
                {
                        return sizeof(*this)+size_*sizeof(link_[0]);
                }

                BYTE ret_code_;                                 // 打开结果: 0成功 1别人已开启
                DWORD operator_id_;                             // 操作者ID
                DWORD cur_version_;                             // 当前版本号
                BYTE cur_page_;                                 // 当前页码
                WORD size_;                                     // 链接长度
                char link_[0];                                  // 链接地址
        };
        struct stRoomUserOwnFlowerReq:
                stRoomCmd
        {
                stRoomUserOwnFlowerReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_OWN_FLOWER_REQ)
                {
                        user_id_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomUserOwnFlowerRes:
                stRoomCmd
        {
                stRoomUserOwnFlowerRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_OWN_FLOWER_RES)
                {
                        user_id_ = 0;
                        own_flower_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
                DWORD own_flower_;                              // 拥有鲜花数
        };
        struct stRoomUserOwnFlowerNotify:
                stRoomCmd
        {
                stRoomUserOwnFlowerNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_OWN_FLOWER_NOTIFY)
                {
                        user_id_ = 0;
                        own_flower_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
                DWORD own_flower_;                              // 拥有鲜花数
        };
        struct stRoomUserSendFlowerReq:
                stRoomCmd
        {
                stRoomUserSendFlowerReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_SEND_FLOWER_REQ)
                {
                        user_id_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
        };
        struct stRoomUserSendFlowerRes:
                stRoomCmd
        {
                stRoomUserSendFlowerRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_SEND_FLOWER_RES)
                {
                        user_id_ = 0;
                        send_flower_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
                DWORD send_flower_;                             // 可送鲜花数
        };
        struct stRoomUserSendFlowerNotify:
                stRoomCmd
        {
                stRoomUserSendFlowerNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_USER_SEND_FLOWER_NOTIFY)
                {
                        send_flower_ = 0;
                }

                DWORD send_flower_;                             // 可送鲜花数
        };
        struct stRoomAddSendFlowerReq:
                stRoomCmd
        {
                stRoomAddSendFlowerReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_SEND_FLOWER_REQ)
                {
                        flower_ = 0;
                        client_flag_ = 0;
                }

                DWORD flower_;                                  // 增加鲜花数
                DWORD client_flag_;                             // 客户端使用
        };
        struct stRoomAddSendFlowerRes:
                stRoomCmd
        {
                stRoomAddSendFlowerRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ADD_SEND_FLOWER_RES)
                {
                        flower_ = 0;
                        client_flag_ = 0;
                        ret_code_ = 0;
                        total_flower_ = 0;
                }

                DWORD flower_;                                  // 增加鲜花数
                DWORD client_flag_;                             // 客户端使用
                BYTE ret_code_;                                 // 增加鲜花结果: 0成功 1失败
                DWORD total_flower_;                            // 可送总线花数
        };
        struct stRoomSendFlowerReq:
                stRoomCmd
        {
                stRoomSendFlowerReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_SEND_FLOWER_REQ)
                {
                        receiver_id_ = 0;
                        flower_ = 0;
                        size_ = 0;
                }

                DWORD getSize() const 
                { 
                        return sizeof(*this) + size_ * sizeof(json_[0]); 
                }

                DWORD receiver_id_;                             // 接收者ID
                DWORD flower_;                                  // 赠送鲜花数
                WORD size_;                                     // json长度
                char json_[0];                                  // json内容
                // json = null
        };
        struct stRoomSendFlowerRes:
                stRoomCmd
        {
                stRoomSendFlowerRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_SEND_FLOWER_RES)
                {
                        receiver_id_ = 0;
                        flower_ = 0;
                        ret_code_ = 0;
                        total_own_flower_ = 0;
                        total_send_flower_ = 0;
                        size_ = 0;
                }

                DWORD getSize() const 
                { 
                        return sizeof(*this) + size_ * sizeof(json_[0]); 
                }

                DWORD receiver_id_;                             // 接收者ID
                DWORD flower_;                                  // 赠送鲜花数
                BYTE ret_code_;                                 // 赠送鲜花结果: 0成功 非0失败
                DWORD total_own_flower_;                        // 接收者拥有总线花数
                DWORD total_send_flower_;                       // 赠送者剩余鲜花数
                WORD size_;                                     // json长度
                char json_[0];                                  // json内容
                // json = null
        };
        struct stRoomSendFlowerNotify:
                stRoomCmd
        {
                stRoomSendFlowerNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_SEND_FLOWER_NOTIFY)
                {
                        presenter_id_ = 0;
                        receiver_id_ = 0;
                        flower_ = 0;
                        total_flower_ = 0;
                        size_ = 0;
                }

                DWORD getSize() const 
                { 
                        return sizeof(*this) + size_ * sizeof(json_[0]); 
                }

                DWORD presenter_id_;                            // 赠送者ID
                DWORD receiver_id_;                             // 接收者ID
                DWORD flower_;                                  // 赠送鲜花数
                DWORD total_flower_;                            // 接收者拥有总线花数
                WORD size_;                                     // json长度
                char json_[0];                                  // json内容
                // json = null
        };
        struct stRoomAnswerCardOpenReq:
                stRoomCmd
        {
                stRoomAnswerCardOpenReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_OPEN_REQ)
                {
                }
        };
        struct stRoomAnswerCardOpenRes:
                stRoomCmd
        {
                stRoomAnswerCardOpenRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_OPEN_RES)
                {
                        ret_code_ = 0;
                }

                BYTE ret_code_;                                 // 开答题卡结果: 0成功 1权限不足 2失败
        };
        struct stRoomAnswerCardCloseReq:
                stRoomCmd
        {
                stRoomAnswerCardCloseReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_CLOSE_REQ)
                {
                }
        };
        struct stRoomAnswerCardCloseRes:
                stRoomCmd
        {
                stRoomAnswerCardCloseRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_CLOSE_RES)
                {
                        ret_code_ = 0;
                }

                BYTE ret_code_;                                 // 关闭答题卡结果: 0成功 1权限不足 2失败
        };
        struct stRoomAnswerCardStatusReq:
                stRoomCmd
        {
                stRoomAnswerCardStatusReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_STATUS_REQ)
                {
                }
        };
        struct stRoomAnswerCardStatusRes:
                stRoomCmd
        {
                stRoomAnswerCardStatusRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_STATUS_RES)
                {
                        ret_code_ = 0;
                        operator_id_ = 0;
                        status_ = eAnswerCardStatus_Enable;
                }

                BYTE ret_code_;                                 // 答题卡状态请求结果: 0成功 1失败
                DWORD operator_id_;                             // 操作者ID
                BYTE status_;                                   // 答题卡状态(eAnswerCardStatus)
        };
        struct stRoomAnswerCardStatusNotify:
                stRoomCmd
        {
                stRoomAnswerCardStatusNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_STATUS_NOTIFY)
                {
                        operator_id_ = 0;
                        status_ = eAnswerCardStatus_Enable;
                }

                DWORD operator_id_;                             // 操作者ID
                BYTE status_;                                   // 答题卡状态(eAnswerCardStatus)
        };
        struct stRoomAnswerCardReq:
                stRoomCmd
        {
                stRoomAnswerCardReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_REQ)
                {
                        operate_type_ = 0;
                }

                DWORD getSize() const 
                { 
                        return sizeof(*this) + size_ * sizeof(json_[0]); 
                }

                WORD operate_type_;                             // 操作类型(eAnswerCardOperateType)
                WORD size_;                                     // json长度
                char json_[0];                                  // json内容(服务器不关心)
        };
        struct stRoomAnswerCardRes:
                stRoomCmd
        {
                stRoomAnswerCardRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_RES)
                {
                        operate_type_ = 0;
                        ret_code_ = 0;
                }

                DWORD getSize() const 
                { 
                        return sizeof(*this) + size_ * sizeof(json_[0]); 
                }

                WORD operate_type_;                             // 操作类型(eAnswerCardOperateType)
                BYTE ret_code_;                                 // 操作结果: 0成功 1权限不足 2状态不对
                WORD size_;                                     // json长度
                char json_[0];                                  // json内容(服务器不关心)
        };
        struct stRoomAnswerCardNotify:
                stRoomCmd
        {
                stRoomAnswerCardNotify():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANSWER_CARD_NOTIFY)
                {
                        operate_type_ = 0;
                        operator_id_ = 0;
                }

                DWORD getSize() const 
                { 
                        return sizeof(*this) + size_ * sizeof(json_[0]); 
                }

                WORD operate_type_;                             // 操作类型(eAnswerCardOperateType)
                DWORD operator_id_;                             // 操作者ID
                WORD size_;                                     // json长度
                char json_[0];                                  // json内容(服务器不关心)
        };
        struct stRoomTopMicReq:
                stRoomCmd
        {
                stRoomTopMicReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_TOP_MIC_REQ)
                {
                }
        };
        struct stRoomTopMicRes:
                stRoomCmd
        {
                stRoomTopMicRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_TOP_MIC_RES)
                {
                        user_id_ = 0;
                }

                DWORD user_id_;                                 // 用户ID
        };

        struct stRoomWBElementReq:
                        stRoomCmd
        {
                stRoomWBElementReq():
                        stRoomCmd(SCMD_ROOM_WB_ELEMENT_REQ)
                {
                        wb_page_ = 0;
                }
                WORD wb_page_;                                  // 页码
        };
        struct stRoomWBElementRes:
                stRoomCmd
        {
                stRoomWBElementRes():
                        stRoomCmd(SCMD_ROOM_WB_ELEMENT_RES)
                {
                        wb_page_ = 0;
                        element_id_ = 0;
                        size_ = 0;
                }
                WORD wb_page_;                                  // 页码
                WORD element_id_;                               // 元素ID
                WORD size_;                                     // 元素大小
                char element_data_[0]; //json                   // 元素内容
                DWORD getSize()
                {
                        return sizeof(*this) + size_*sizeof(element_data_[0]);
                }
        };
        struct stRoomWBElementAdd:
                stRoomCmd
        {
                stRoomWBElementAdd():
                        stRoomCmd(SCMD_ROOM_WB_ELEMENT_ADD)
                {
                        wb_page_ = 0;
                        element_id_ = 0;
                        size_ = 0;
                }
                WORD wb_page_;                                  // 页码
                WORD element_id_;                               // 元素ID
                WORD size_;                                     // 元素大小
                char element_data_[0]; //json                   // 元素内容
                DWORD getSize()
                {
                        return sizeof(*this) + size_*sizeof(element_data_[0]);
                }
        };
        struct stRoomWBElementDel:
                stRoomCmd
        {
                stRoomWBElementDel():
                        stRoomCmd(SCMD_ROOM_WB_ELEMENT_DEL)
                {
                        wb_page_ = 0;
                        element_id_ = 0;
                }
                WORD wb_page_;                                  // 页码
                WORD element_id_;                               // 元素ID
        };
        struct stRoomWBElementLaserPen:
                stRoomCmd
        {
                stRoomWBElementLaserPen():
                        stRoomCmd(SCMD_ROOM_WB_ELEMENT_LASER_PEN)
                {
                        wb_page_ = 0;
                        size_ = 0;
                }
                WORD wb_page_;                                  // 页码
                WORD size_;                                     // 元素大小
                char element_data_[0]; //json                   // 元素内容
                DWORD getSize()
                {
                        return sizeof(*this) + size_*sizeof(element_data_[0]);
                }
        };
        struct stRoomUserStateListReq:
                stRoomCmd
        {
                stRoomUserStateListReq():
                        stRoomCmd(SCMD_ROOM_USER_STATE_LIST_REQ)
                {
                        state_ = USER_STATE_ONLINE;
                }
                BYTE state_;                                    // 在线状态
        };
        struct stRoomUserStateListRes:
                stRoomCmd
        {
                stRoomUserStateListRes():
                        stRoomCmd(SCMD_ROOM_USER_STATE_LIST_RES)
                {
                        state_ = 0;
                        size_  = 0;
                }
                BYTE state_;                                    // 在线状态
                WORD size_;                                     // 用户列表大小
                DWORD users_[0];                                // 用户列表
                DWORD getSize()
                {
                        return sizeof(*this) + size_*sizeof(users_[0]);
                }
        };
        struct stRoomClassEVALTimeNotify:
                stRoomCmd
        {
                stRoomClassEVALTimeNotify():
                        stRoomCmd(SCMD_ROOM_CLASS_EVAL_TIME_NOTIFY)
                {
                        minutes_enable_ = 0;
                        minutes_disable_ = 0;
                }

                uint16_t minutes_enable_;                       // 开课前多久弹出
                uint16_t minutes_disable_;                      // 下课后多久关闭
        };
        struct stRoomQuestionListReq:
                stRoomCmd
        {
                stRoomQuestionListReq():
                        stRoomCmd(SCMD_ROOM_QUESTION_LIST_REQ)
                {
                }
        };
        struct stRoomQuestionListRes:
                stRoomCmd
        {
                stRoomQuestionListRes():
                        stRoomCmd(SCMD_ROOM_QUESTION_LIST_RES)
                {
                        clear_flag_ = 0;
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint8_t clear_flag_;            // 1 for clear  // 是否清空标志
                uint16_t size_;                                 // 问题列表大小
                char json_[0];                                  // 问题列表
                // json_ = questions(array)
                // question = question_id(uint) + question(string) + ask_user(uint) + ask_user_name(string) + ask_time(uint) + highlight(bool) + solve(bool) + solve_time(uint) + like_num(uint)
        };
        struct stRoomAskQuestionReq:
                stRoomCmd
        {
                stRoomAskQuestionReq():
                        stRoomCmd(SCMD_ROOM_ASK_QUESTION_REQ)
                {
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(data_[0]);
                }

                uint16_t size_;                                 // 问题长度
                char data_[0];                                  // 问题内容
        };
        struct stRoomAskQuestionRes:
                stRoomCmd
        {
                stRoomAskQuestionRes():
                        stRoomCmd(SCMD_ROOM_ASK_QUESTION_RES)
                {
                        ret_code_ = 0;
                        question_id_ = 0;
                        ask_time_ = 0;
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(data_[0]);
                }

                uint8_t ret_code_;                              // 提问结果: 0 for success, 1 nopower
                uint32_t question_id_;                          // 问题ID
                uint32_t ask_time_;                             // 提问时间
                uint16_t size_;                                 // 问题长度
                char data_[0];                                  // 问题内容
        };
        struct stRoomAskQuestionNotify:
                stRoomCmd
        {
                stRoomAskQuestionNotify():
                        stRoomCmd(SCMD_ROOM_ASK_QUESTION_NOTIFY)
                {
                        user_ask_ = 0;
                        question_id_ = 0;
                        ask_time_ = 0;
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(data_[0]);
                }

                uint32_t user_ask_;                             // 提问用户ID
                uint32_t question_id_;                          // 问题ID
                uint32_t ask_time_;                             // 提问时间
                uint16_t size_;                                 // 问题长度
                char data_[0];                                  // 问题内容
        };
        struct stRoomLikeQuestionReq:
                stRoomCmd
        {
                stRoomLikeQuestionReq():
                        stRoomCmd(SCMD_ROOM_LIKE_QUESTION_REQ)
                {
                        question_id_ = 0;
                        like_ = 0;
                }

                uint32_t question_id_;                          // 问题ID
                uint8_t like_;                                  // 是否同问(1 for like)
        };
        struct stRoomLikeQuestionRes:
                stRoomCmd
        {
                stRoomLikeQuestionRes():
                        stRoomCmd(SCMD_ROOM_LIKE_QUESTION_RES)
                {
                        ret_code_ = 0;
                        question_id_ = 0;
                        like_ = 0;
                        like_num_ = 0;
                }

                uint8_t ret_code_;                              // 同问结果: 0 for success, 1 nopower 2 notfound 3 duplicate 4 self
                uint32_t question_id_;                          // 问题ID
                uint8_t like_;                                  // 是否同问(1 for like)
                uint32_t like_num_;                             // 同问数
        };
        struct stRoomLikeQuestionNotify:
                stRoomCmd
        {
                stRoomLikeQuestionNotify():
                        stRoomCmd(SCMD_ROOM_LIKE_QUESTION_NOTIFY)
                {
                        user_like_ = 0;
                        question_id_ = 0;
                        like_ = 0;
                        like_num_ = 0;
                }

                uint32_t user_like_;                            // 同问用户ID
                uint32_t question_id_;                          // 问题ID
                uint8_t like_;                                  // 是否同问(1 for like)
                uint32_t like_num_;                             // 同问数
        };
        struct stRoomModifyQuestionReq:
                stRoomCmd
        {
                stRoomModifyQuestionReq():
                        stRoomCmd(SCMD_ROOM_MODIFY_QUESTION_REQ)
                {
                        question_id_ = 0;
                        modify_type_ = eQuestionModifyType_highlight;
                        client_flag_ = 0;
                }

                uint32_t question_id_;                          // 问题ID
                uint8_t modify_type_;                           // 改变问题状态(参见eQuestionModifyType)
                uint8_t client_flag_;                           // 客户端使用
        };
        struct stRoomModifyQuestionRes:
                stRoomCmd
        {
                stRoomModifyQuestionRes():
                        stRoomCmd(SCMD_ROOM_MODIFY_QUESTION_RES)
                {
                        ret_code_ = 0;
                        question_id_ = 0;
                        modify_type_ = eQuestionModifyType_highlight;
                        modify_time_ = 0;
                        client_flag_ = 0;
                }

                uint8_t ret_code_;                              // 改变问题状态结果: 0 for success, 1 nopower 2 notfound 3 duplicate
                uint32_t question_id_;                          // 问题ID
                uint8_t modify_type_;                           // 改变问题状态(参见eQuestionModifyType)
                uint32_t modify_time_;                          // 改变时间
                uint8_t client_flag_;                           // 客户端使用
        };
        struct stRoomModifyQuestionNotify:
                stRoomCmd
        {
                stRoomModifyQuestionNotify():
                        stRoomCmd(SCMD_ROOM_MODIFY_QUESTION_NOTIFY)
                {
                        user_modify_ = 0;
                        question_id_ = 0;
                        modify_type_ = eQuestionModifyType_highlight;
                        modify_time_ = 0;
                        client_flag_ = 0;
                }

                uint32_t user_modify_;                          // 用户ID
                uint32_t question_id_;                          // 问题ID
                uint8_t modify_type_;                           // 改变问题状态(参见eQuestionModifyType)
                uint32_t modify_time_;                          // 改变时间
                uint8_t client_flag_;                           // 客户端使用
        };
        struct stRoomClassInfoReq:
                stRoomCmd
        {
                stRoomClassInfoReq():
                        stRoomCmd(SCMD_ROOM_CLASS_INFO_REQ)
                {
                }
        };
        struct stRoomClassInfoRes:
                stRoomCmd
        {
                stRoomClassInfoRes():
                        stRoomCmd(SCMD_ROOM_CLASS_INFO_RES)
                {
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint16_t size_;                                 // json长度
                char json_[0];                                  // json内容
                // json_ = class_info(value) + teacher_info(value)
                // class_info = start_time(uint)
                // teacher_info = id(uint) + account(string) + nickname(string) + flower(uint) + inroom(bool)
        };
        struct stRoomQuestionLikeListReq:
                stRoomCmd
        {
                stRoomQuestionLikeListReq():
                        stRoomCmd(SCMD_ROOM_QUESTION_LIKE_LIST_REQ)
                {
                }
        };
        struct stRoomQuestionLikeListRes:
                stRoomCmd
        {
                stRoomQuestionLikeListRes():
                        stRoomCmd(SCMD_ROOM_QUESTION_LIKE_LIST_RES)
                {
                        clear_flag_ = 0;
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint8_t clear_flag_;                            // 是否清空标志: 1 for clear
                uint16_t size_;                                 // json长度
                char json_[0];                                  // json内容
                // json_ = questionids(array)
                // questionid(uint)
        };
        struct stRoomJoin :
                stRoomCmd
        {
                stRoomJoin():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_JOIN)
                {
                        with_password_ = 0;
                        bzero(password_, sizeof(password_));
                }

                uint8_t with_password_;	                        // 是否携带密码: 0-no, 1-yes
                char password_[MAX_PASSWORD_SIZE+1];            // 密码
        };
        struct stRoomReqUserList :
                stRoomCmd
        {
                stRoomReqUserList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_USER_LIST)
                {
                }
        };
        struct stRoomResUserList :
                stRoomCmd
        {
                stRoomResUserList():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_USER_LIST)
                {
                        size_ = 0;
                        finish_ = 0;
                }
 
                uint32_t getSize() const
                {
                        return sizeof(*this)+size_*sizeof(list_[0]);
                }
               
                uint16_t size_;                                 // 列表大小
                uint8_t finish_;                                // 是否结束标志: 0-no, 1-yes
                struct stRUL {
                        uint32_t user_id_;                      // 用户ID
                        char user_name_[MAX_ACCOUNT_SIZE+1];    // 用户帐号
                        char nick_name_[MAX_NAME_SIZE+1];       // 用户昵称
                        uint8_t show_identity_;                 // 显示身份
                        uint8_t terminal_;                      // 终端类型(eTerminalType)
                } list_[0];
        };
        struct stRoomReqClassBegin:
                stRoomCmd
        {
                stRoomReqClassBegin():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_CLASS_BEGIN)
                {
                }
        };
        struct stRoomResClassBegin:
                stRoomCmd
        {
                stRoomResClassBegin():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_CLASS_BEGIN)
                {
                        ret_code_ = 0;
                }

                uint8_t ret_code_;                              // 上课结果: 0 成功 1 权限不足 2 已有人在上课
        };
        struct stRoomNotifyClassBegin:
                stRoomCmd
        {
                stRoomNotifyClassBegin():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_CLASS_BEGIN)
                {
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint16_t size_;                                 // json长度
                char json_[0];                                  // json内容
                // json_ = class_info(value) + teacher_info(value)
                // class_info = start_time(uint)
                // teacher_info = id(uint) + account(string) + nickname(string) + flower(uint) + inroom(bool)
        };
        struct stRoomReqClassEnd:
                stRoomCmd
        {
                stRoomReqClassEnd():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_CLASS_END)
                {
                }
        };
        struct stRoomResClassEnd:
                stRoomCmd
        {
                stRoomResClassEnd():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_CLASS_END)
                {
                        ret_code_ = 0;
                }

                uint8_t ret_code_;                              // 下课结果: 0 成功 1 没有权限
        };
        struct stRoomNotifyClassEnd:
                stRoomCmd
        {
                stRoomNotifyClassEnd():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_CLASS_END)
                {
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint16_t size_;                                 // json长度
                char json_[0];                                  // json内容
                // json_ = class_info(value)
                // class_info = stop_time(uint)
        };
        struct stRoomReqClassEndForce:
                stRoomCmd
        {
                stRoomReqClassEndForce():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_CLASS_END_FORCE)
                {
                }
        };
        struct stRoomResClassEndForce:
                stRoomCmd
        {
                stRoomResClassEndForce():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_CLASS_END_FORCE)
                {
                        ret_code_ = 0;
                }

                uint8_t ret_code_;                              // 强制下课结果: 0 成功 1 没有权限 2 没有人在上课
        };
        struct stRoomNotifyClassEndForce:
                stRoomCmd
        {
                stRoomNotifyClassEndForce():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_CLASS_END_FORCE)
                {
                        operator_id_ = 0;
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint32_t operator_id_;                          // 操作者ID
                uint16_t size_;                                 // json长度
                char json_[0];                                  // json内容
                // json_ = class_info(value)
                // class_info = stop_time(uint)
        };
        struct stRoomControlStatusSet:
                stRoomCmd
        {
                stRoomControlStatusSet():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CONTROL_STATUS_SET)
                {
                        control_status_ = 0;
                }

                uint32_t control_status_;                       // 功能控制(按位表示,每位属性参考eRoomControlStatusType)
        };
        struct stRoomNotifyJoin:
                stRoomCmd
        {
                stRoomNotifyJoin():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_JOIN)
                {
                        user_id_ = 0;
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint32_t user_id_;                              // 用户ID
                uint16_t size_;                                 // json长度
                char json_[0];                                  // json内容
                // json_ = account(string) + nickname(string) + terminal(uint) + identity(uint)
        };
        struct stRoomSpeakUsersReq:
                stRoomCmd
        {
                stRoomSpeakUsersReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_SPEAK_USERS_REQ)
                {
                }
        };
        struct stRoomSpeakUsersRes:
                stRoomCmd
        {
                stRoomSpeakUsersRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_SPEAK_USERS_RES)
                {
                        size_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(list_[0]);
                }

                uint32_t size_;                                 // 说话用户列表大小
                struct stSpeakInfo{
                        uint32_t userid;                        // 用户ID
                        uint32_t time;	                        // 已经说话的时长
                        uint8_t timetype;	                // 时间计时方式: 0-dec, 1-inc
                } list_[0];
        };
        struct stRoomDalabaReq:
                stRoomCmd
        {
                stRoomDalabaReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_DALABA_REQ)
                {
                }
        };
        struct stRoomClassEVALTimeReq:
                stRoomCmd
        {
                stRoomClassEVALTimeReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_CLASS_EVAL_TIME_REQ)
                {
                }
        };
        struct stRoomBaseInfoReq:
                stRoomCmd
        {
                stRoomBaseInfoReq():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_BASE_INFO_REQ)
                {
                }
        };
        struct stRoomBaseInfoRes:
                stRoomCmd
        {
                stRoomBaseInfoRes():
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_BASE_INFO_RES)
                {
                        bzero(name_, sizeof(name_));
                        mode_ = eRoomMode_Dialog;
                        mic_time_ = DEFAULT_MIC_TIME;
                        fidelity_ = 0;
                        app_bit_mask_ = 0;
                        functionality_status_ = 0;
                }

                char name_[MAX_ROOM_NAME_SIZE+1];               // 房间名称
                uint8_t mode_;                                  // 房间模式(eRoomMode)
                uint16_t mic_time_;                             // 麦序时间
                uint8_t fidelity_;                              // 音质模式(0-high 1-middle 2-low)
                uint32_t app_bit_mask_;                         // 房间应用(按位表示. eRoomAppBitMask)
                uint32_t functionality_status_;                 // 功能控制(按位表示,每位属性参考eRoomControlStatusType)
        };

        struct stRoomReqUserIDList :
                stRoomCmd
        {
                stRoomReqUserIDList() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_USER_ID_LIST)
                {
                }
        };
        struct stRoomResUserIDList :
                stRoomCmd
        {
                stRoomResUserIDList() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_USER_ID_LIST)
                {
                        size_ = 0;
                        finish_ = 0;
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(list_[0]);
                }

                uint16_t size_;                                 // 用户信息列表大小
                uint8_t finish_;                                // 是否结束标记: 0-no, 1-yes
                struct user_info_t {
                        uint32_t user_id_;                      // 用户ID
                        uint8_t show_identity_;                 // 显示的身份
                        uint8_t terminal_;                      // 终端类型(eTerminalType)
                } list_[0];
        };

        struct stRoomReqDisableMediaData :
                stRoomCmd
        {
                stRoomReqDisableMediaData() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_MUTE_MEDIA_DATA)
                {
                }
                uint32_t user_id;                               // 用户ID
                uint8_t data_type;                              // UDP数据类型(ref: eUDPDataType)
                uint8_t enable;                                 // 是否禁用: 0 -- disable, 1 -- enable
        };
        
        struct stRoomResDisableMediaData :
                stRoomCmd
        {
                stRoomResDisableMediaData() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_MUTE_MEDIA_DATA)
                {
                }
                uint32_t ret_code;                              // 禁用UDP数据结果
        };

        struct stRoomReqUserInfoList :
                stRoomCmd {
                stRoomReqUserInfoList() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_REQ_USER_INFO_LIST)
                {
                        num_ = 0;
                }
                uint32_t num_;                                  // 用户信息个数
                uint32_t list_[0];                              // 用户信息数组头
                uint32_t getSize()
                {
                        return sizeof(*this) + num_ * sizeof(list_[0]);
                }
        };

        struct stRoomResUserInfoList :
                stRoomCmd {
                stRoomResUserInfoList() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_RES_USER_INFO_LIST)
                {
                        len_ = 0;
                        finish_ = 0;
                }
                uint32_t len_;                                  // 数据长度
                uint8_t  finish_;                               // 是否结束标记: 0-not finish; 1-finish
                char data_[0];                                  // json格式,例如:[{id:111,nk:"ahui4367",acc:"ahui4367"},{id:111,nk:"hui4367",acc:"ahui4367"}]
                uint32_t getSize()
                {
                        return sizeof(*this) + len_ * sizeof(data_[0]);
                }
        };

        struct stRoomNotifyChangeModeNew:
                stRoomCmd
        {
                stRoomNotifyChangeModeNew() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_NOTIFY_CHANGE_MODE_NEW)
                {
                        operator_ = 0;
                        mode_ = eRoomMode_Dialog;
                }

                uint32_t operator_;                             // 操作者ID
                uint8_t mode_;                                  // 房间模式
        };

        struct stRoomAnotherMediaAddrReq:
                stRoomCmd
        {
                stRoomAnotherMediaAddrReq() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANOTHER_MEDIA_ADDR_REQ)
                {
                }

                uint32_t getSize() const
                {
                        return sizeof(*this) + size_*sizeof(json_[0]);
                }

                uint16_t size_;                                 // 条件长度
                char json_[0];                                  // 条件内容
                // json_ = prefer_list(array) + used_list(array)
                // prefer_list = computer_room_id(uint)...
                // used_list = computer_room_id(uint)...
        };
        
        struct stRoomAnotherMediaAddrRet:
                stRoomCmd
        {
                stRoomAnotherMediaAddrRet() :
                        stRoomCmd(CMD_ROOM, SCMD_ROOM_ANOTHER_MEDIA_ADDR_RET)
                {
                        ip_ = 0;
                        port_ = 0;
                        computer_room_id_ = -1;
                }
                
                uint32_t ip_;                                   // RoomMedia IP
                uint16_t port_;                                 // RoomMedia 端口
                int16_t computer_room_id_;                      // 机房ID
        };
}; //namespace Cmd
#pragma pack()

#ifdef _WIN32
#pragma warning( pop )
#endif

#endif //COMMAND_ROOM_COMMAND_H_
